/* Copyright (C) 2008  Romolo Camplani, Marco Fortunato, Marco Marelli, Guido Rota, Fabio A. Schreiber et al.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
package org.dei.perla.sys.device.channel.frame;

import java.util.ArrayList;

import org.dei.perla.sys.configuration.ConfigurationParameter;
import org.dei.perla.sys.device.channel.frame.header.FrameHeader;

/**
 * Parametri di configurazione di un generico frame 
 */
public class FrameConfiguration {

	/**
	 * Costanti di configurazione del parser dell'XML di configurazione
	 */
	private final static String PARAM_BYTE_ESCAPE 			= "frame-byte-escape";
	private final static String PARAM_DELIM_START_HDRFULL 	= "frame-byte-delim-start-hdrfull";
	private final static String PARAM_DELIM_START_HDRLESS 	= "frame-byte-delim-start-hdrless";
	private final static String PARAM_DELIM_END 			= "frame-byte-delim-end";
	private final static String PARAM_BUFFER_SIZE 			= "frame-buffer-size";
	
	/**
	 * Byte di escape
	 */
	private byte pByteEscape;

	/**
	 * Delimitatore di inizio frame headerful
	 */
	private byte pByteDelimiterStartHeaderFul;

	/**
	 * Delimitatore di inizio frame headerless
	 */
	private byte pByteDelimiterStartHeaderLess;

	/**
	 * Terminatore frame
	 */
	private byte pByteDelimiterEnd;

	/**
	 * Dimensione del buffer di ricezione
	 */
	private int pBufferSize;
	
	/**
	 * Contiene l'header del frame
	 */
	private FrameHeader pFrameHeader;

	/**
	 * Inizializza la configurazione di un frame
	 * @param parParams Parametri di configurazione
	 * @param parHeader Header da utilizzare per il frame
	 */
	public FrameConfiguration(ArrayList<ConfigurationParameter> parParams, FrameHeader parHeader) {
		
		this.pFrameHeader = parHeader;
	
		// Leggi i parametri di configurazione
		for (int i = 0; i < parParams.size(); i++) {
			
			ConfigurationParameter tCurrParam = parParams.get(i);
			
			if ( tCurrParam.getName().equalsIgnoreCase(FrameConfiguration.PARAM_BYTE_ESCAPE)) {
				this.pByteEscape = new Integer(tCurrParam.getValue()).byteValue();
			} else if ( tCurrParam.getName().equalsIgnoreCase(FrameConfiguration.PARAM_DELIM_START_HDRFULL)) {
				this.pByteDelimiterStartHeaderFul = new Integer(tCurrParam.getValue()).byteValue();
			} else if ( tCurrParam.getName().equalsIgnoreCase(FrameConfiguration.PARAM_DELIM_START_HDRLESS)) {
				this.pByteDelimiterStartHeaderLess = new Integer(tCurrParam.getValue()).byteValue();
			} else if ( tCurrParam.getName().equalsIgnoreCase(FrameConfiguration.PARAM_DELIM_END)) {
				this.pByteDelimiterEnd = new Integer(tCurrParam.getValue()).byteValue();
			} else if ( tCurrParam.getName().equalsIgnoreCase(FrameConfiguration.PARAM_BUFFER_SIZE)) {
				this.pBufferSize = new Integer(tCurrParam.getValue()).intValue();
			}
		
		}
		
	}
	
	/**
	 * Inizializza la configurazione di un frame
	 * @param parByteEscape
	 * @param parByteDelimiterStartAddressFull
	 * @param parByteDelimiterStartAddressLess
	 * @param parByteDelimiterEnd
	 * @param parBufferSize
	 * @param parFrameHeader
	 */
	public FrameConfiguration(byte parByteEscape, byte parByteDelimiterStartAddressFull, 
			byte parByteDelimiterStartAddressLess, byte parByteDelimiterEnd,
			int parBufferSize,
			FrameHeader parFrameHeader ) {

		this.pByteEscape 					= parByteEscape;
		this.pByteDelimiterStartHeaderFul 	= parByteDelimiterStartAddressFull;
		this.pByteDelimiterStartHeaderLess 	= parByteDelimiterStartAddressLess;
		this.pByteDelimiterEnd 				= parByteDelimiterEnd;
		this.pBufferSize 					= parBufferSize;
		this.pFrameHeader					= parFrameHeader;
	}

	/**
	 * Restituisce il byte di escape
	 */
	public byte getByteEscape() {
		return this.pByteEscape;
	}

	/**
	 * Restituisce il delimitatore di inizio frame headerful
	 */
	public byte getByteDelimiterStartHeaderFul() {
		return this.pByteDelimiterStartHeaderFul;
	}

	/**
	 * Restituisce il delimitatore di inizio frame headerless
	 */
	public byte getByteDelimiterStartHeaderLess() {
		return this.pByteDelimiterStartHeaderLess;
	}

	/**
	 * Restituisce il delimitatore di fine frame
	 */
	public byte getByteDelimiterEnd() {
		return this.pByteDelimiterEnd;
	}

	/**
	 * Restituisce la dimensione del buffer di ricezione
	 */
	public int getBufferSize() {
		return this.pBufferSize;
	}

	/**
	 * Restituisce l'header da utilizzare per il pacchetto
	 */
	public FrameHeader getFrameHeader() {
		return this.pFrameHeader;
	}

}